{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Understanding Dyna-Q: Integrating Learning and Planning\n",
    "\n",
    "# Table of Contents\n",
    "\n",
    "- [Introduction: Model-Based Reinforcement Learning](#introduction)\n",
    "- [What is Dyna-Q?](#what-is-dyna-q)\n",
    "  - [Direct RL vs. Planning](#direct-rl-vs-planning)\n",
    "  - [The Dyna Architecture](#the-dyna-architecture)\n",
    "- [Why Dyna-Q? The Value of a Model](#why-dyna-q)\n",
    "- [Where and How Dyna-Q is Used](#where-and-how-dyna-q-is-used)\n",
    "- [Mathematical Foundation of Dyna-Q](#mathematical-foundation-of-dyna-q)\n",
    "  - [Q-Learning Recap (Direct RL Component)](#q-learning-recap)\n",
    "  - [Model Learning (Tabular Case)](#model-learning-tabular-case)\n",
    "  - [Planning (Simulated Experience Update)](#planning-simulated-experience-update)\n",
    "- [Step-by-Step Explanation of Dyna-Q](#step-by-step-explanation-of-dyna-q)\n",
    "- [Key Components of Dyna-Q](#key-components-of-dyna-q)\n",
    "  - [Action-Value Function (Q-Table)](#action-value-function-q-table)\n",
    "  - [Environment Model (Learned)](#environment-model-learned)\n",
    "  - [Direct Reinforcement Learning Update](#direct-reinforcement-learning-update)\n",
    "  - [Planning Updates (Model-Based)](#planning-updates-model-based)\n",
    "  - [Exploration vs. Exploitation](#exploration-vs-exploitation)\n",
    "  - [Number of Planning Steps (k)](#number-of-planning-steps-k)\n",
    "  - [Hyperparameters](#hyperparameters)\n",
    "- [Practical Example: Custom Grid World](#practical-example-custom-grid-world)\n",
    "  - [Why Grid World for Dyna-Q?](#why-grid-world)\n",
    "- [Setting up the Environment](#setting-up-the-environment)\n",
    "- [Creating the Custom Environment](#creating-the-custom-environment)\n",
    "- [Implementing the Dyna-Q Algorithm](#implementing-the-dyna-q-algorithm)\n",
    "  - [Representing the Q-Table and Model](#representing-the-q-table-and-model)\n",
    "  - [Action Selection (Epsilon-Greedy)](#action-selection-epsilon-greedy)\n",
    "  - [Direct RL Update (Q-Learning)](#direct-rl-update-q-learning)\n",
    "  - [Model Update](#model-update)\n",
    "  - [Planning Step Function](#planning-step-function)\n",
    "  - [Dyna-Q Agent Class (Optional Structure)](#dyna-q-agent-class-optional-structure)\n",
    "- [Running the Dyna-Q Algorithm](#running-the-dyna-q-algorithm)\n",
    "  - [Hyperparameter Setup](#hyperparameter-setup)\n",
    "  - [Initialization](#initialization)\n",
    "  - [Training Loop](#training-loop)\n",
    "- [Visualizing the Learning Process](#visualizing-the-learning-process)\n",
    "- [Analyzing the Learned Policy and Model (Optional Visualization)](#analyzing-the-learned-policy-and-model-optional-visualization)\n",
    "- [Common Challenges and Extensions of Dyna-Q](#common-challenges-and-extensions-of-dyna-q)\n",
    "- [Conclusion](#conclusion)\n",
    "\n",
    "## Introduction: Model-Based Reinforcement Learning\n",
    "\n",
    "Reinforcement Learning algorithms can be broadly categorized into **model-free** and **model-based** approaches.\n",
    "\n",
    "- **Model-Free RL:** Algorithms like Q-Learning, DQN, REINFORCE, A2C, PPO learn directly from interaction with the environment through trial and error. They learn a value function or a policy without explicitly building a representation of the environment's dynamics (transitions and rewards).\n",
    "- **Model-Based RL:** Algorithms learn a *model* of the environment (approximating the transition function $P(s'|s,a)$ and reward function $R(s,a,s')$) based on experience. This learned model can then be used for *planning* – simulating interactions within the model to improve the value function or policy without requiring additional real-world interaction.\n",
    "\n",
    "Dyna-Q is a classic example that integrates model-free learning with model-based planning.\n",
    "\n",
    "## What is Dyna-Q?\n",
    "\n",
    "Dyna-Q, introduced by Richard Sutton, is an architecture that combines **Direct Reinforcement Learning** (learning from real experience) with **Planning** (learning from simulated experience generated by a learned model). It operates by interleaving steps of acting in the real world, learning from that real experience (both updating values/policy and updating the model), and then performing multiple planning steps using the learned model.\n",
    "\n",
    "### Direct RL vs. Planning\n",
    "- **Direct RL:** The agent takes an action $a_t$ in the real environment state $s_t$, observes the next state $s_{t+1}$ and reward $r_t$. This real transition $(s_t, a_t, r_t, s_{t+1})$ is used to update the agent's value function (e.g., Q-table) using a standard model-free algorithm like Q-Learning.\n",
    "- **Model Learning:** The same real transition $(s_t, a_t, r_t, s_{t+1})$ is also used to update the agent's internal model of the environment. In the tabular case, this often means storing the observed outcome: Model $(s_t, a_t) \\rightarrow (r_t, s_{t+1})$.\n",
    "- **Planning:** The agent performs $k$ additional updates using *simulated* experiences. In each planning step, it:\n",
    "    1.  Randomly samples a state $s$ and action $a$ that it has *previously experienced*.\n",
    "    2.  Consults its learned model to predict the resulting reward $r$ and next state $s'$: $(r, s') = \text{Model}(s, a)$.\n",
    "    3.  Applies the same Direct RL update rule (e.g., Q-Learning) to the value function using this simulated transition $(s, a, r, s')$.\n",
    "\n",
    "### The Dyna Architecture\n",
    "The name \"Dyna\" reflects this dynamic interplay: real experience improves the model and the value function/policy directly, while the model allows for planning steps that further improve the value function/policy indirectly through simulation.\n",
    "\n",
    "## Why Dyna-Q? The Value of a Model\n",
    "\n",
    "Model-based approaches like Dyna-Q offer significant advantages, primarily in **sample efficiency**:\n",
    "\n",
    "1.  **Data Efficiency:** Real-world interactions can be expensive or slow. By learning a model, the agent can generate many simulated transitions from a single real transition. These simulated experiences allow for many more updates to the value function or policy than would be possible with only direct RL, leading to faster learning from fewer real-world interactions.\n",
    "2.  **Focused Updates:** Planning steps can potentially focus updates on important parts of the state-action space or propagate value information more quickly through simulated trajectories.\n",
    "3.  **Adaptability:** If the environment changes, the model can potentially be updated, allowing the planning process to quickly adapt the policy (though basic Dyna-Q addresses this more simply with Dyna-Q+).\n",
    "\n",
    "The main cost is the need to learn and store the model, and the computational expense of the planning steps. The quality of the learned policy also depends on the accuracy of the learned model.\n",
    "\n",
    "## Where and How Dyna-Q is Used\n",
    "\n",
    "Dyna-Q is foundational and particularly illustrative in:\n",
    "\n",
    "1.  **Tabular RL Problems:** Environments with discrete states and actions where Q-tables and simple models can be learned effectively (e.g., grid worlds, simple mazes).\n",
    "2.  **Scenarios Requiring High Sample Efficiency:** When real environment interaction is costly.\n",
    "3.  **Educational Purposes:** Clearly demonstrates the concept of integrating model learning and planning.\n",
    "\n",
    "While the basic Dyna-Q uses tabular Q-learning and a simple deterministic model, the Dyna architecture can be extended:\n",
    "- Using function approximation (neural networks) for the value function/policy and the model (e.g., Dyna-DQN).\n",
    "- Learning probabilistic models.\n",
    "- Using more sophisticated planning algorithms (e.g., Monte Carlo Tree Search) with the learned model.\n",
    "\n",
    "## Mathematical Foundation of Dyna-Q\n",
    "\n",
    "Dyna-Q primarily relies on the mathematics of its underlying components: Q-learning for direct RL and model updates, and the Q-learning update rule applied during planning.\n",
    "\n",
    "### Q-Learning Recap (Direct RL Component)\n",
    "The agent maintains an action-value function $Q(s, a)$, representing the expected return starting from state $s$, taking action $a$, and following the current policy thereafter. For a *real* transition $(s_t, a_t, r_t, s_{t+1})$, the Q-value is updated using the TD error:\n",
    "$$ Q(s_t, a_t) \\leftarrow Q(s_t, a_t) + \\alpha \\left[ r_t + \\gamma \\max_{a'} Q(s_{t+1}, a') - Q(s_t, a_t) \\right] $$\n",
    "where $\\alpha$ is the learning rate and $\\gamma$ is the discount factor.\n",
    "\n",
    "### Model Learning (Tabular Case)\n",
    "The model $Model(s, a)$ stores the observed outcome of taking action $a$ in state $s$. For a deterministic environment, after observing $(s_t, a_t, r_t, s_{t+1})$, the model is updated:\n",
    "$$ Model(s_t, a_t) \\leftarrow (r_t, s_{t+1}) $$\n",
    "This is typically stored in a dictionary or hash map where the key is the `(state, action)` pair.\n",
    "\n",
    "### Planning (Simulated Experience Update)\n",
    "During each planning step, the agent:\n",
    "1.  Selects a state-action pair $(s_p, a_p)$ that has been previously observed (i.e., exists in the `Model`).\n",
    "2.  Retrieves the simulated outcome from the model: $(r_p, s'_p) = Model(s_p, a_p)$.\n",
    "3.  Applies the Q-learning update using this *simulated* transition:\n",
    "    $$ Q(s_p, a_p) \\leftarrow Q(s_p, a_p) + \\alpha \\left[ r_p + \\gamma \\max_{a'} Q(s'_p, a') - Q(s_p, a_p) \\right] $$\n",
    "This allows propagating value information based on the learned model without interacting with the real environment.\n",
    "\n",
    "## Step-by-Step Explanation of Dyna-Q\n",
    "\n",
    "1.  **Initialize**: Q-table $Q(s, a)$ (e.g., to zeros), Model $Model(s, a)$ (empty). Hyperparameters $\\alpha, \\gamma, \\epsilon$, planning steps $k$.\n",
    "2.  **Loop for each episode**:\n",
    "    a.  Get initial state $s$ from environment.\n",
    "    b.  **Loop for each step of episode**:\n",
    "        i.   Choose action $a$ from state $s$ using policy based on $Q$ (e.g., $\\epsilon$-greedy).\n",
    "        ii.  Take action $a$, observe real reward $r$ and next state $s'$.\n",
    "        iii. **Direct RL Update**: Update $Q(s, a)$ using the real transition $(s, a, r, s')$ via Q-learning rule.\n",
    "        iv.  **Model Update**: Store the observed transition: $Model(s, a) \\leftarrow (r, s')$. Add $(s,a)$ to list of observed pairs if needed for sampling.\n",
    "        v.   **Planning**: Repeat $k$ times:\n",
    "            1.  Randomly sample a state $s_p$ and action $a_p$ from *previously observed* pairs.\n",
    "            2.  Get simulated outcome $(r_p, s'_p) = Model(s_p, a_p)$.\n",
    "            3.  Apply Q-learning update to $Q(s_p, a_p)$ using $(s_p, a_p, r_p, s'_p)$.\n",
    "        vi.  Update state: $s \\leftarrow s'$.\n",
    "        vii. If $s'$ is terminal, break episode step loop.\n",
    "3.  **Repeat**: Until convergence or max episodes.\n",
    "\n",
    "## Key Components of Dyna-Q\n",
    "\n",
    "### Action-Value Function (Q-Table)\n",
    "- Stores the estimated value of taking each action in each state.\n",
    "- Typically a dictionary or multi-dimensional array in the tabular case.\n",
    "- Updated by both Direct RL and Planning steps.\n",
    "\n",
    "### Environment Model (Learned)\n",
    "- Stores the learned dynamics (transitions and rewards).\n",
    "- In tabular Dyna-Q, often a dictionary mapping `(state, action)` tuples to `(reward, next_state)` tuples.\n",
    "- Updated only from *real* environment interactions.\n",
    "\n",
    "### Direct Reinforcement Learning Update\n",
    "- Updates the Q-table based on actual transitions experienced in the environment (e.g., Q-learning).\n",
    "\n",
    "### Planning Updates (Model-Based)\n",
    "- Updates the Q-table based on simulated transitions generated by querying the learned model.\n",
    "- Performed $k$ times after each real step.\n",
    "\n",
    "### Exploration vs. Exploitation\n",
    "- Handled by the policy derived from the Q-table during *real* interaction (e.g., $\\epsilon$-greedy).\n",
    "- Planning steps typically use the learned Q-values directly for updates (exploiting the current value estimates within the model).\n",
    "\n",
    "### Number of Planning Steps (k)\n",
    "- A crucial hyperparameter controlling the amount of planning relative to direct interaction. $k=0$ recovers model-free Q-learning. Larger $k$ increases computational cost but can significantly speed up learning if the model is accurate.\n",
    "\n",
    "### Hyperparameters\n",
    "- Learning rate ($\\alpha$), discount factor ($\\gamma$), exploration rate ($\\epsilon$).\n",
    "- Number of planning steps ($k$).\n",
    "\n",
    "## Practical Example: Custom Grid World\n",
    "\n",
    "### Why Grid World for Dyna-Q?\n",
    "The Grid World is ideal for demonstrating Dyna-Q because:\n",
    "1.  **Discrete States/Actions:** Fits the tabular representation of the Q-function and the model used in classic Dyna-Q.\n",
    "2.  **Simplicity:** The dynamics are easy to understand and learn, allowing focus on the Dyna-Q mechanism itself.\n",
    "3.  **Determinism (Optional):** A deterministic version allows the model to become perfectly accurate quickly, clearly showing the benefit of planning. We'll use the deterministic version here.\n",
    "4.  **Visualization:** Q-values, the model, and the policy can be easily visualized.\n",
    "\n",
    "**Environment Description:** (Same as before, using tuple states)\n",
    "- Grid Size: 10x10.\n",
    "- **State:** Agent's `(row, col)` tuple.\n",
    "- Actions: 4 discrete (0: Up, 1: Down, 2: Left, 3: Right).\n",
    "- Start: (0, 0), Goal: (9, 9).\n",
    "- Rewards: +10 (goal), -1 (wall), -0.1 (step).\n",
    "- Termination: Goal or max steps.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Setting up the Environment\n",
    "\n",
    "Import libraries. We only need basic Python data structures and `numpy`/`matplotlib`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Import necessary libraries\n",
    "import numpy as np\n",
    "import matplotlib.pyplot as plt\n",
    "import random\n",
    "from collections import defaultdict # Useful for Q-table and model\n",
    "from typing import Tuple, Dict, Any, List, DefaultDict\n",
    "\n",
    "# Set random seeds for reproducibility\n",
    "seed = 42\n",
    "random.seed(seed)\n",
    "np.random.seed(seed)\n",
    "\n",
    "%matplotlib inline"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Creating the Custom Environment\n",
    "\n",
    "Using the `GridEnvironment` class, slightly modified to return state tuples directly, suitable for tabular methods."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "class GridEnvironmentTabular:\n",
    "    \"\"\"\n",
    "    Grid World returning state tuples, suitable for tabular methods.\n",
    "    Rewards: +10 (goal), -1 (wall), -0.1 (step).\n",
    "    \"\"\"\n",
    "    def __init__(self, rows: int = 10, cols: int = 10) -> None:\n",
    "        self.rows: int = rows\n",
    "        self.cols: int = cols\n",
    "        self.start_state: Tuple[int, int] = (0, 0)\n",
    "        self.goal_state: Tuple[int, int] = (rows - 1, cols - 1)\n",
    "        self.state: Tuple[int, int] = self.start_state\n",
    "        self.action_dim: int = 4\n",
    "        self.action_map: Dict[int, Tuple[int, int]] = {0: (-1, 0), 1: (1, 0), 2: (0, -1), 3: (0, 1)}\n",
    "\n",
    "    def reset(self) -> Tuple[int, int]:\n",
    "        \"\"\" Resets environment, returns state tuple. \"\"\"\n",
    "        self.state = self.start_state\n",
    "        return self.state\n",
    "\n",
    "    def step(self, action: int) -> Tuple[Tuple[int, int], float, bool]:\n",
    "        \"\"\"\n",
    "        Performs one step, returns (next_state_tuple, reward, done).\n",
    "        \"\"\"\n",
    "        if self.state == self.goal_state:\n",
    "            return self.state, 0.0, True\n",
    "        \n",
    "        dr, dc = self.action_map[action]\n",
    "        current_row, current_col = self.state\n",
    "        next_row, next_col = current_row + dr, current_col + dc\n",
    "        \n",
    "        reward: float = -0.1\n",
    "        if not (0 <= next_row < self.rows and 0 <= next_col < self.cols):\n",
    "            next_row, next_col = current_row, current_col # Stay in place\n",
    "            reward = -1.0\n",
    "            \n",
    "        self.state = (next_row, next_col)\n",
    "        next_state_tuple = self.state\n",
    "        \n",
    "        done: bool = (self.state == self.goal_state)\n",
    "        if done:\n",
    "            reward = 10.0\n",
    "            \n",
    "        return next_state_tuple, reward, done\n",
    "\n",
    "    def get_action_space_size(self) -> int:\n",
    "        return self.action_dim"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Instantiate and test the environment."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Tabular Grid Environment:\n",
      "Size: 10x10\n",
      "Action Dim: 4\n",
      "Start State: (0, 0)\n",
      "Step result (action=Right): next_state=(0, 1), reward=-0.1, done=False\n"
     ]
    }
   ],
   "source": [
    "custom_env_tabular = GridEnvironmentTabular(rows=10, cols=10)\n",
    "n_actions_tabular = custom_env_tabular.get_action_space_size()\n",
    "\n",
    "print(f\"Tabular Grid Environment:\")\n",
    "print(f\"Size: {custom_env_tabular.rows}x{custom_env_tabular.cols}\")\n",
    "print(f\"Action Dim: {n_actions_tabular}\")\n",
    "start_state_tuple = custom_env_tabular.reset()\n",
    "print(f\"Start State: {start_state_tuple}\")\n",
    "next_s, r, d = custom_env_tabular.step(3) # Move Right\n",
    "print(f\"Step result (action=Right): next_state={next_s}, reward={r}, done={d}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Implementing the Dyna-Q Algorithm\n",
    "\n",
    "We'll implement Dyna-Q using functions or optionally within an Agent class for structure.\n",
    "\n",
    "### Representing the Q-Table and Model\n",
    "\n",
    "`defaultdict` is convenient for Q-tables (returns 0 for unvisited state-actions) and the model."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Initialize Q-table and Model\n",
    "# Q-table maps (state_tuple, action) -> Q-value\n",
    "Q_table: DefaultDict[Tuple[Tuple[int, int], int], float] = defaultdict(float)\n",
    "\n",
    "# Model maps (state_tuple, action) -> (reward, next_state_tuple)\n",
    "Model: Dict[Tuple[Tuple[int, int], int], Tuple[float, Tuple[int, int]]] = {}\n",
    "\n",
    "# Keep track of observed state-action pairs for planning sampling\n",
    "Observed_State_Actions: List[Tuple[Tuple[int, int], int]] = []"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Action Selection (Epsilon-Greedy)\n",
    "\n",
    "Standard epsilon-greedy selection based on the Q-table."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "def choose_action_epsilon_greedy(state: Tuple[int, int], \n",
    "                                 q_table: DefaultDict[Tuple[Tuple[int, int], int], float], \n",
    "                                 epsilon: float, \n",
    "                                 n_actions: int) -> int:\n",
    "    \"\"\"\n",
    "    Chooses an action using epsilon-greedy policy based on the Q-table.\n",
    "    \n",
    "    Parameters:\n",
    "    - state (Tuple[int, int]): The current state tuple.\n",
    "    - q_table (DefaultDict): The current Q-value estimates.\n",
    "    - epsilon (float): The probability of choosing a random action.\n",
    "    - n_actions (int): The total number of possible actions.\n",
    "    \n",
    "    Returns:\n",
    "    - int: The chosen action index.\n",
    "    \"\"\"\n",
    "    if random.random() < epsilon:\n",
    "        # Explore: choose a random action\n",
    "        return random.randrange(n_actions)\n",
    "    else:\n",
    "        # Exploit: choose the best action based on Q-values\n",
    "        q_values = [q_table[(state, a)] for a in range(n_actions)]\n",
    "        max_q = max(q_values)\n",
    "        # Handle ties by choosing randomly among best actions\n",
    "        best_actions = [a for a, q in enumerate(q_values) if q == max_q]\n",
    "        return random.choice(best_actions)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Direct RL Update (Q-Learning)\n",
    "\n",
    "Performs the Q-learning update on the Q-table."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "def q_learning_update(q_table: DefaultDict[Tuple[Tuple[int, int], int], float],\n",
    "                        state: Tuple[int, int],\n",
    "                        action: int,\n",
    "                        reward: float,\n",
    "                        next_state: Tuple[int, int],\n",
    "                        alpha: float,\n",
    "                        gamma: float,\n",
    "                        n_actions: int,\n",
    "                        is_done: bool) -> None:\n",
    "    \"\"\"\n",
    "    Performs a single Q-learning update step.\n",
    "    \n",
    "    Parameters:\n",
    "    - q_table: The Q-table to update.\n",
    "    - state, action, reward, next_state, is_done: Transition elements.\n",
    "    - alpha: Learning rate.\n",
    "    - gamma: Discount factor.\n",
    "    - n_actions: Number of actions.\n",
    "    \"\"\"\n",
    "    # Get current Q-value\n",
    "    current_q = q_table[(state, action)]\n",
    "    \n",
    "    # Get max Q-value for the next state (target)\n",
    "    if is_done:\n",
    "        target_q = 0.0 # No future reward if episode is done\n",
    "    else:\n",
    "        next_q_values = [q_table[(next_state, a)] for a in range(n_actions)]\n",
    "        max_next_q = max(next_q_values) if next_q_values else 0.0\n",
    "        target_q = max_next_q\n",
    "        \n",
    "    # Calculate TD target and TD error\n",
    "    td_target = reward + gamma * target_q\n",
    "    td_error = td_target - current_q\n",
    "    \n",
    "    # Update Q-value\n",
    "    new_q = current_q + alpha * td_error\n",
    "    q_table[(state, action)] = new_q"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Model Update\n",
    "\n",
    "Updates the learned model with the observed transition."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "def update_model(model: Dict[Tuple[Tuple[int, int], int], Tuple[float, Tuple[int, int]]],\n",
    "                 observed_pairs: List[Tuple[Tuple[int, int], int]],\n",
    "                 state: Tuple[int, int],\n",
    "                 action: int,\n",
    "                 reward: float,\n",
    "                 next_state: Tuple[int, int]) -> None:\n",
    "    \"\"\"\n",
    "    Updates the deterministic tabular model.\n",
    "    \n",
    "    Parameters:\n",
    "    - model: The model dictionary.\n",
    "    - observed_pairs: List tracking observed (state, action) pairs.\n",
    "    - state, action, reward, next_state: Transition elements.\n",
    "    \"\"\"\n",
    "    state_action = (state, action)\n",
    "    # Store the observed outcome\n",
    "    model[state_action] = (reward, next_state)\n",
    "    \n",
    "    # Add to list of observed pairs if not already present (for planning sampling)\n",
    "    # Using a set for efficient checking might be better for large state spaces,\n",
    "    # but a list is simpler for this example.\n",
    "    if state_action not in observed_pairs:\n",
    "        observed_pairs.append(state_action)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Planning Step Function\n",
    "\n",
    "Performs `k` planning updates using the model."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "def planning_steps(k: int,\n",
    "                   q_table: DefaultDict[Tuple[Tuple[int, int], int], float],\n",
    "                   model: Dict[Tuple[Tuple[int, int], int], Tuple[float, Tuple[int, int]]],\n",
    "                   observed_pairs: List[Tuple[Tuple[int, int], int]],\n",
    "                   alpha: float,\n",
    "                   gamma: float,\n",
    "                   n_actions: int) -> None:\n",
    "    \"\"\"\n",
    "    Performs 'k' planning steps using the learned model.\n",
    "    \n",
    "    Parameters:\n",
    "    - k: Number of planning steps.\n",
    "    - q_table, model, observed_pairs: Agent's components.\n",
    "    - alpha, gamma, n_actions: Hyperparameters.\n",
    "    \"\"\"\n",
    "    if not observed_pairs: # Cannot plan if nothing has been observed\n",
    "        return\n",
    "        \n",
    "    for _ in range(k):\n",
    "        # Sample a random previously observed state-action pair\n",
    "        state_p, action_p = random.choice(observed_pairs)\n",
    "        \n",
    "        # Get the simulated reward and next state from the model\n",
    "        reward_p, next_state_p = model[(state_p, action_p)]\n",
    "        \n",
    "        # Perform Q-learning update using the simulated experience\n",
    "        # Note: The simulated next state might not be terminal, so is_done is False\n",
    "        # In more complex models/environments, the model might also predict termination.\n",
    "        q_learning_update(q_table, state_p, action_p, reward_p, next_state_p,\n",
    "                          alpha, gamma, n_actions, is_done=False) "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Dyna-Q Agent Class (Optional Structure)\n",
    "\n",
    "We can group these components into a class for better organization, mirroring the structure used for network-based agents."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "class DynaQAgent:\n",
    "    \"\"\" Encapsulates the Dyna-Q algorithm components and logic. \"\"\"\n",
    "    def __init__(self, n_actions: int, \n",
    "                 alpha: float, gamma: float, epsilon: float, \n",
    "                 planning_steps: int):\n",
    "        self.n_actions: int = n_actions\n",
    "        self.alpha: float = alpha\n",
    "        self.gamma: float = gamma\n",
    "        self.epsilon: float = epsilon\n",
    "        self.k: int = planning_steps\n",
    "        \n",
    "        self.q_table: DefaultDict[Tuple[Tuple[int, int], int], float] = defaultdict(float)\n",
    "        self.model: Dict[Tuple[Tuple[int, int], int], Tuple[float, Tuple[int, int]]] = {}\n",
    "        self.observed_pairs: List[Tuple[Tuple[int, int], int]] = []\n",
    "\n",
    "    def choose_action(self, state: Tuple[int, int]) -> int:\n",
    "        \"\"\" Choose action using epsilon-greedy. \"\"\"\n",
    "        return choose_action_epsilon_greedy(state, self.q_table, self.epsilon, self.n_actions)\n",
    "\n",
    "    def learn(self, state: Tuple[int, int], action: int, reward: float, \n",
    "              next_state: Tuple[int, int], done: bool) -> None:\n",
    "        \"\"\"\n",
    "        Perform Direct RL update, Model update, and Planning steps.\n",
    "        \"\"\"\n",
    "        # Direct RL Update\n",
    "        q_learning_update(self.q_table, state, action, reward, next_state, \n",
    "                          self.alpha, self.gamma, self.n_actions, done)\n",
    "        \n",
    "        # Model Update\n",
    "        update_model(self.model, self.observed_pairs, state, action, reward, next_state)\n",
    "        \n",
    "        # Planning\n",
    "        planning_steps(self.k, self.q_table, self.model, self.observed_pairs, \n",
    "                       self.alpha, self.gamma, self.n_actions)\n",
    "                       \n",
    "    def update_epsilon(self, new_epsilon: float) -> None:\n",
    "        \"\"\" Update the exploration rate. \"\"\"\n",
    "        self.epsilon = new_epsilon"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Running the Dyna-Q Algorithm\n",
    "\n",
    "Set up hyperparameters, initialize the agent, and run the training loop.\n",
    "\n",
    "### Hyperparameter Setup\n",
    "\n",
    "Define Dyna-Q hyperparameters."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Hyperparameters for Dyna-Q on Custom Grid World\n",
    "ALPHA = 0.1                 # Learning rate\n",
    "GAMMA = 0.95                # Discount factor\n",
    "EPSILON_START = 1.0         # Initial exploration rate\n",
    "EPSILON_END = 0.01          # Final exploration rate\n",
    "EPSILON_DECAY = 0.995       # Epsilon decay factor per episode\n",
    "PLANNING_STEPS_K = 50       # Number of planning steps (k)\n",
    "\n",
    "NUM_EPISODES_DYNAQ = 500    # Number of training episodes\n",
    "MAX_STEPS_PER_EPISODE_DYNAQ = 200 # Max steps per episode"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Initialization\n",
    "\n",
    "Initialize the environment and the Dyna-Q agent."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Instantiate the environment\n",
    "env_dynaq = GridEnvironmentTabular(rows=10, cols=10)\n",
    "n_actions = env_dynaq.get_action_space_size()\n",
    "\n",
    "# Initialize the Dyna-Q Agent\n",
    "agent = DynaQAgent(n_actions=n_actions,\n",
    "                   alpha=ALPHA,\n",
    "                   gamma=GAMMA,\n",
    "                   epsilon=EPSILON_START,\n",
    "                   planning_steps=PLANNING_STEPS_K)\n",
    "\n",
    "# Lists for plotting\n",
    "dynaq_episode_rewards = []\n",
    "dynaq_episode_lengths = []\n",
    "dynaq_episode_epsilons = []"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Training Loop\n",
    "\n",
    "The Dyna-Q training loop interleaves acting, learning, and planning."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Starting Dyna-Q Training (k=50)...\n",
      "Episode 50/500 | Avg Reward (last 50): -15.37 | Avg Length: 130.0 | Epsilon: 0.778\n",
      "Episode 100/500 | Avg Reward (last 50): 1.82 | Avg Length: 51.7 | Epsilon: 0.606\n",
      "Episode 150/500 | Avg Reward (last 50): 4.09 | Avg Length: 38.3 | Epsilon: 0.471\n",
      "Episode 200/500 | Avg Reward (last 50): 5.81 | Avg Length: 31.9 | Epsilon: 0.367\n",
      "Episode 250/500 | Avg Reward (last 50): 6.50 | Avg Length: 28.1 | Epsilon: 0.286\n",
      "Episode 300/500 | Avg Reward (last 50): 7.26 | Avg Length: 23.2 | Epsilon: 0.222\n",
      "Episode 350/500 | Avg Reward (last 50): 7.53 | Avg Length: 22.1 | Epsilon: 0.173\n",
      "Episode 400/500 | Avg Reward (last 50): 7.63 | Avg Length: 20.9 | Epsilon: 0.135\n",
      "Episode 450/500 | Avg Reward (last 50): 7.75 | Avg Length: 20.2 | Epsilon: 0.105\n",
      "Episode 500/500 | Avg Reward (last 50): 7.89 | Avg Length: 19.7 | Epsilon: 0.082\n",
      "Grid World Training Finished (Dyna-Q).\n"
     ]
    }
   ],
   "source": [
    "print(f\"Starting Dyna-Q Training (k={PLANNING_STEPS_K})...\")\n",
    "\n",
    "# --- Dyna-Q Training Loop ---\n",
    "current_epsilon = EPSILON_START\n",
    "\n",
    "for i_episode in range(1, NUM_EPISODES_DYNAQ + 1):\n",
    "    state: Tuple[int, int] = env_dynaq.reset()\n",
    "    episode_reward: float = 0.0\n",
    "    \n",
    "    agent.update_epsilon(current_epsilon) # Set current epsilon for the agent\n",
    "    \n",
    "    for t in range(MAX_STEPS_PER_EPISODE_DYNAQ):\n",
    "        # Choose action\n",
    "        action: int = agent.choose_action(state)\n",
    "        \n",
    "        # Interact with environment\n",
    "        next_state, reward, done = env_dynaq.step(action)\n",
    "        \n",
    "        # Learn (Direct RL, Model Update, Planning)\n",
    "        agent.learn(state, action, reward, next_state, done)\n",
    "        \n",
    "        state = next_state\n",
    "        episode_reward += reward\n",
    "        \n",
    "        if done:\n",
    "            break\n",
    "            \n",
    "    # --- End of Episode --- \n",
    "    dynaq_episode_rewards.append(episode_reward)\n",
    "    dynaq_episode_lengths.append(t + 1)\n",
    "    dynaq_episode_epsilons.append(current_epsilon)\n",
    "    \n",
    "    # Decay epsilon\n",
    "    current_epsilon = max(EPSILON_END, current_epsilon * EPSILON_DECAY)\n",
    "    \n",
    "    # Print progress\n",
    "    if i_episode % 50 == 0:\n",
    "        avg_reward = np.mean(dynaq_episode_rewards[-50:])\n",
    "        avg_length = np.mean(dynaq_episode_lengths[-50:])\n",
    "        print(f\"Episode {i_episode}/{NUM_EPISODES_DYNAQ} | Avg Reward (last 50): {avg_reward:.2f} | Avg Length: {avg_length:.1f} | Epsilon: {current_epsilon:.3f}\")\n",
    "\n",
    "print(\"Grid World Training Finished (Dyna-Q).\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Visualizing the Learning Process\n",
    "\n",
    "Plot episode rewards, lengths, and epsilon decay."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 1800x400 with 3 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Plotting results for Dyna-Q on Custom Grid World\n",
    "plt.figure(figsize=(18, 4))\n",
    "\n",
    "# Rewards\n",
    "plt.subplot(1, 3, 1)\n",
    "plt.plot(dynaq_episode_rewards)\n",
    "plt.title(f'Dyna-Q (k={PLANNING_STEPS_K}): Episode Rewards')\n",
    "plt.xlabel('Episode')\n",
    "plt.ylabel('Total Reward')\n",
    "plt.grid(True)\n",
    "if len(dynaq_episode_rewards) >= 50:\n",
    "    rewards_ma_dynaq = np.convolve(dynaq_episode_rewards, np.ones(50)/50, mode='valid')\n",
    "    plt.plot(np.arange(len(rewards_ma_dynaq)) + 49, rewards_ma_dynaq, label='50-episode MA', color='orange')\n",
    "    plt.legend()\n",
    "\n",
    "# Lengths\n",
    "plt.subplot(1, 3, 2)\n",
    "plt.plot(dynaq_episode_lengths)\n",
    "plt.title(f'Dyna-Q (k={PLANNING_STEPS_K}): Episode Lengths')\n",
    "plt.xlabel('Episode')\n",
    "plt.ylabel('Steps')\n",
    "plt.grid(True)\n",
    "if len(dynaq_episode_lengths) >= 50:\n",
    "    lengths_ma_dynaq = np.convolve(dynaq_episode_lengths, np.ones(50)/50, mode='valid')\n",
    "    plt.plot(np.arange(len(lengths_ma_dynaq)) + 49, lengths_ma_dynaq, label='50-episode MA', color='orange')\n",
    "    plt.legend()\n",
    "\n",
    "# Epsilon\n",
    "plt.subplot(1, 3, 3)\n",
    "plt.plot(dynaq_episode_epsilons)\n",
    "plt.title('Dyna-Q: Epsilon Decay')\n",
    "plt.xlabel('Episode')\n",
    "plt.ylabel('Epsilon')\n",
    "plt.grid(True)\n",
    "\n",
    "plt.tight_layout()\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Analysis of Dyna-Q (k=50) Learning Curves (Custom Grid World):**\n",
    "\n",
    "1.  **Episode Rewards:**\n",
    "    The agent learns effectively, with the moving average (orange line) showing a steady and significant increase in rewards, particularly between episodes ~50 and 200, before plateauing near the optimal value (around 8). The raw rewards (blue line) exhibit moderate variance during learning but stabilize considerably once the optimal policy is found, indicating successful convergence.\n",
    "\n",
    "2.  **Episode Lengths:**\n",
    "    Correspondingly, the average episode length decreases substantially over time. The moving average shows a clear downward trend, converging towards the optimal path length (~18 steps) by around episode 300. The raw lengths are initially very noisy but become much more consistent as the agent learns and exploration (epsilon) decreases.\n",
    "\n",
    "3.  **Epsilon Decay:**\n",
    "    The epsilon value, controlling the exploration rate (probability of choosing a random action), decays exponentially from 1.0 towards a low value (near 0.05) over the 500 episodes. This planned reduction in exploration allows the agent to initially explore the environment broadly and then increasingly exploit its learned knowledge (the Q-values updated by both real and model-simulated experience). The decay rate seems well-matched to the learning progress observed in the other plots.\n",
    "\n",
    "**Overall Conclusion:**\n",
    "Dyna-Q (with k=50 planning steps) successfully solved the Grid World task, demonstrating efficient learning by combining direct reinforcement learning with model-based planning. The agent learned both a high-reward and an efficient path policy, converging stably. The effectiveness is aided by the planned exploration decay and the additional updates derived from the learned world model, potentially leading to faster convergence than purely model-free methods like basic Q-learning in some scenarios."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Analyzing the Learned Policy and Model (Optional Visualization)\n",
    "\n",
    "Visualize the final policy derived from the learned Q-table."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "Plotting Learned Policy from Dyna-Q:\n"
     ]
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 600x600 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "def plot_tabular_policy_grid(q_table: DefaultDict[Tuple[Tuple[int, int], int], float], \n",
    "                             env: GridEnvironmentTabular) -> None:\n",
    "    \"\"\"\n",
    "    Plots the greedy policy derived from a tabular Q-table.\n",
    "    \"\"\"\n",
    "    rows: int = env.rows\n",
    "    cols: int = env.cols\n",
    "    policy_grid: np.ndarray = np.empty((rows, cols), dtype=str)\n",
    "    action_symbols: Dict[int, str] = {0: '↑', 1: '↓', 2: '←', 3: '→'} \n",
    "\n",
    "    fig, ax = plt.subplots(figsize=(cols * 0.6, rows * 0.6))\n",
    "\n",
    "    for r in range(rows):\n",
    "        for c in range(cols):\n",
    "            state_tuple: Tuple[int, int] = (r, c)\n",
    "            if state_tuple == env.goal_state:\n",
    "                policy_grid[r, c] = 'G'\n",
    "                ax.text(c, r, 'G', ha='center', va='center', color='green', fontsize=12, weight='bold')\n",
    "            else:\n",
    "                q_values = [q_table[(state_tuple, a)] for a in range(env.get_action_space_size())]\n",
    "                if not q_values or all(q == 0 for q in q_values): # If state not visited or all Q=0\n",
    "                    best_action = -1 # Indicate no learned action yet\n",
    "                    symbol = '.'\n",
    "                else:\n",
    "                    max_q = max(q_values)\n",
    "                    best_actions = [a for a, q in enumerate(q_values) if q == max_q]\n",
    "                    best_action = random.choice(best_actions) # Break ties randomly\n",
    "                    symbol = action_symbols[best_action]\n",
    "                \n",
    "                policy_grid[r, c] = symbol\n",
    "                ax.text(c, r, symbol, ha='center', va='center', color='black', fontsize=12)\n",
    "\n",
    "    ax.matshow(np.zeros((rows, cols)), cmap='Greys', alpha=0.1)\n",
    "    ax.set_xticks(np.arange(-.5, cols, 1), minor=True)\n",
    "    ax.set_yticks(np.arange(-.5, rows, 1), minor=True)\n",
    "    ax.grid(which='minor', color='black', linestyle='-', linewidth=1)\n",
    "    ax.set_xticks([])\n",
    "    ax.set_yticks([])\n",
    "    ax.set_title(f\"Dyna-Q (k={PLANNING_STEPS_K}) Learned Policy\")\n",
    "    plt.show()\n",
    "\n",
    "# Plot the final policy\n",
    "print(\"\\nPlotting Learned Policy from Dyna-Q:\")\n",
    "plot_tabular_policy_grid(agent.q_table, env_dynaq)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Common Challenges and Extensions of Dyna-Q\n",
    "\n",
    "**Challenge: Model Accuracy**\n",
    "*   **Problem:** The effectiveness of planning depends entirely on the accuracy of the learned model. If the model is poor (especially in stochastic or complex environments), planning with it can reinforce incorrect dynamics and lead to suboptimal policies.\n",
    "*   **Solutions**:\n",
    "    *   **Sufficient Exploration:** Ensure the agent explores enough to experience diverse transitions for model learning.\n",
    "    *   **Model Uncertainty:** More advanced methods track uncertainty in the model and adjust planning accordingly.\n",
    "    *   **Probabilistic Models:** Learn a distribution $P(s', r | s, a)$ instead of just one outcome.\n",
    "    * **Limit Planning:** Reduce $k$ if the model is suspected to be inaccurate.\n",
    "\n",
    "**Challenge: Computational Cost of Planning**\n",
    "*   **Problem:** Performing $k$ updates per real step can become computationally expensive, especially if $k$ is large or the state space is huge.\n",
    "*   **Solutions**:\n",
    "    *   **Optimize $k$:** Choose a moderate value for $k$.\n",
    "    *   **Prioritized Sweeping:** An extension where planning steps are focused on states whose values are likely to change the most (e.g., predecessors of states whose value just changed significantly), rather than purely random sampling.\n",
    "\n",
    "**Challenge: Scalability (Tabular Limitation)**\n",
    "*   **Problem:** Basic tabular Dyna-Q doesn't scale to large or continuous state/action spaces.\n",
    "*   **Solutions**:\n",
    "    *   **Function Approximation:** Use neural networks for the Q-function (or policy) and potentially for the model (e.g., learning a dynamics network $s_{t+1} = f(s_t, a_t)$). This leads to Dyna-style algorithms with function approximation (e.g., Dyna-DQN, World Models).\n",
    "\n",
    "**Challenge: Deterministic Model Limitation**\n",
    "*   **Problem:** The simple model `Model(s, a) -> (r, s')` assumes deterministic transitions. It only stores the *last* observed outcome.\n",
    "*   **Solutions**:\n",
    "    *   **Learn Frequencies/Probabilities:** Store counts or estimate probabilities $P(s', r | s, a)$ for stochastic environments.\n",
    "    *   **More Complex Models:** Use Gaussian processes or neural networks capable of representing distributions.\n",
    "\n",
    "**Extension: Dyna-Q+**\n",
    "*   Addresses environments where dynamics might change. It adds an \"exploration bonus\" to encourage trying actions in states that haven't been visited recently, potentially discovering changes in the environment dynamics more quickly.\n",
    "\n",
    "## Conclusion\n",
    "\n",
    "Dyna-Q provides a clear and effective framework for integrating model-free learning with model-based planning. By learning a model of the environment from real interactions and using it to generate simulated experiences for additional updates, it can significantly improve sample efficiency compared to purely model-free methods like Q-learning ($k=0$).\n",
    "\n",
    "Its core strength lies in leveraging each real experience multiple times—once for direct learning and model improvement, and potentially many times via simulated planning steps. While the basic tabular implementation has limitations in scalability and handling stochasticity, the underlying Dyna architecture is a powerful concept that forms the basis for many advanced model-based reinforcement learning algorithms that utilize function approximation and more sophisticated planning techniques."
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": ".venv-all-rl-algos",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.9.0"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}
